/**
 * 本地组件合并工具 - 标准模板
 * Phase 5 集成验证关键工具
 *
 * 用途：将 LOCAL_TEST_COMPONENTS 智能合并到左侧组件菜单
 * 特点：基于现有分组结构，避免覆盖，确保兼容性
 *
 * @template Phase5/Integration
 * @version 2.0.0 (基于案例版本优化)
 * @author AI Assistant
 * @date 2025-11-10
 */

import { LOCAL_TEST_COMPONENTS } from '@/constants/constants';

// 标准接口定义 - 与系统期望格式一致
interface ComponentItem {
  componentCode?: string;
  componentName?: string;
  componentType?: string;
  propertiesSource?: string;
  stylesSource?: string;
  applyPageTypes?: string;  // 注意：必须是字符串格式 '1'/'2'/'3'
  [key: string]: any;
}

interface SubGroupItem {
  groupId?: number;
  groupName?: string;
  thumbnail?: string;
  componentList?: ComponentItem[];
}

interface GroupItem {
  groupId?: number;
  groupName?: string;
  groupCode?: string;      // 关键字段：用于匹配现有分组
  thumbnail?: string;
  subGroupList?: SubGroupItem[];
}

/**
 * 深拷贝子分组 - 避免引用问题
 */
const cloneSubGroup = (sub: SubGroupItem): SubGroupItem => ({
  ...sub,
  componentList: [...(sub.componentList || [])],
});

/**
 * 深拷贝分组 - 避免引用问题
 */
const cloneGroup = (group: GroupItem): GroupItem => ({
  ...group,
  subGroupList: (group.subGroupList || []).map(cloneSubGroup),
});

/**
 * 智能合并本地测试组件到现有组件列表
 *
 * 核心逻辑：
 * 1. 优先通过 groupCode 匹配现有分组
 * 2. 备用通过 groupName 匹配
 * 3. 在现有分组中添加组件，不破坏原结构
 * 4. 避免重复添加相同组件
 *
 * @param originList 原始组件列表（来自API或mockData）
 * @returns 合并后的组件列表
 */
export const mergeLocalComponents = (originList: GroupItem[] = []): GroupItem[] => {
  // 边界检查：无本地组件时直接返回
  if (!LOCAL_TEST_COMPONENTS || LOCAL_TEST_COMPONENTS.length === 0) {
    console.warn('LOCAL_TEST_COMPONENTS 为空，跳过合并');
    return originList;
  }

  // 深拷贝原始列表，避免修改原数据
  const cloned = originList.map(cloneGroup);

  // 调试信息
  console.log(`开始合并 ${LOCAL_TEST_COMPONENTS.length} 个本地分组到 ${cloned.length} 个现有分组`);

  // 合并本地组件到现有列表
  LOCAL_TEST_COMPONENTS.forEach((localGroup) => {
    console.log(`处理本地分组: ${localGroup.groupName} (${localGroup.groupCode})`);

    // 关键：通过 groupCode 或 groupName 查找现有分组
    const targetGroup = cloned.find(
      (group) =>
        group.groupCode === localGroup.groupCode ||
        group.groupName === localGroup.groupName
    );

    if (targetGroup) {
      console.log(`找到匹配分组: ${targetGroup.groupName}`);

      // 合并子分组到现有分组
      localGroup.subGroupList?.forEach((localSub) => {
        console.log(`  处理子分组: ${localSub.groupName}`);

        const targetSub = targetGroup.subGroupList?.find(
          (sub) => sub.groupName === localSub.groupName
        );

        if (targetSub) {
          // 添加组件到现有子分组，避免重复
          const existCodes = new Set(
            (targetSub.componentList || []).map((item) => item.componentCode)
          );

          const addedComponents: string[] = [];
          (localSub.componentList || []).forEach((comp) => {
            if (!existCodes.has(comp.componentCode)) {
              targetSub.componentList = [...(targetSub.componentList || []), { ...comp }];
              existCodes.add(comp.componentCode);
              addedComponents.push(comp.componentCode || 'unknown');
            }
          });

          console.log(`    添加组件: ${addedComponents.join(', ')}`);
        } else {
          // 创建新子分组
          targetGroup.subGroupList = [...(targetGroup.subGroupList || []), cloneSubGroup(localSub)];
          console.log(`    创建新子分组: ${localSub.groupName}`);
        }
      });
    } else {
      // 创建新分组
      cloned.push(cloneGroup(localGroup));
      console.log(`创建新分组: ${localGroup.groupName}`);
    }
  });

  console.log(`合并完成，最终分组数: ${cloned.length}`);
  return cloned;
};

/**
 * 检查组件是否为本地AI组件
 * 用于区分本地组件和远程组件
 */
export const isLocalAIComponent = (componentCode: string): boolean => {
  return LOCAL_TEST_COMPONENTS.some((group) =>
    group.subGroupList?.some((subGroup) =>
      subGroup.componentList?.some((component) => component.componentCode === componentCode)
    )
  );
};

/**
 * 验证 LOCAL_TEST_COMPONENTS 配置完整性
 * Phase 5 验证工具
 */
export const validateLocalComponentsConfig = (): boolean => {
  console.log('验证 LOCAL_TEST_COMPONENTS 配置...');

  let isValid = true;
  const errors: string[] = [];

  LOCAL_TEST_COMPONENTS.forEach((group, groupIndex) => {
    // 检查分组必需字段
    if (!group.groupCode) {
      errors.push(`分组 ${groupIndex}: 缺少 groupCode`);
      isValid = false;
    }
    if (!group.groupName) {
      errors.push(`分组 ${groupIndex}: 缺少 groupName`);
      isValid = false;
    }

    // 检查子分组
    group.subGroupList?.forEach((subGroup, subIndex) => {
      if (!subGroup.groupName) {
        errors.push(`分组 ${groupIndex} 子分组 ${subIndex}: 缺少 groupName`);
        isValid = false;
      }

      // 检查组件
      subGroup.componentList?.forEach((component, compIndex) => {
        if (!component.componentCode) {
          errors.push(`分组 ${groupIndex} 子分组 ${subIndex} 组件 ${compIndex}: 缺少 componentCode`);
          isValid = false;
        }
        if (!component.componentName) {
          errors.push(`分组 ${groupIndex} 子分组 ${subIndex} 组件 ${compIndex}: 缺少 componentName`);
          isValid = false;
        }
        if (typeof component.applyPageTypes !== 'string') {
          errors.push(`分组 ${groupIndex} 子分组 ${subIndex} 组件 ${compIndex}: applyPageTypes 必须是字符串`);
          isValid = false;
        }
      });
    });
  });

  if (!isValid) {
    console.error('LOCAL_TEST_COMPONENTS 配置验证失败:');
    errors.forEach(error => console.error(`  - ${error}`));
  } else {
    console.log('LOCAL_TEST_COMPONENTS 配置验证通过');
  }

  return isValid;
};

export default mergeLocalComponents;

/*
使用示例 (Phase 5 集成验证)：

1. 在 src/pages/editor/index.tsx 中导入：
   import { mergeLocalComponents } from '@/utils/mergeLocalComponents';

2. 在组件查询函数中使用：
   const mergedComList = mergeLocalComponents([...CONTAINER_LIST, ...allComList]);

3. 添加调试信息（开发阶段）：
   console.log('Before merge:', allComList.find(g => g.groupName === 'Telecom'));
   const mergedComList = mergeLocalComponents([...CONTAINER_LIST, ...allComList]);
   console.log('After merge:', mergedComList.find(g => g.groupName === 'Telecom'));

4. 验证配置完整性：
   import { validateLocalComponentsConfig } from '@/utils/mergeLocalComponents';
   validateLocalComponentsConfig(); // 在开发阶段调用

常见问题排查：

□ groupCode 是否与现有系统分组一致？
□ applyPageTypes 是否使用字符串格式？
□ 子分组名称是否存在于目标分组中？
□ 是否在所有入口文件中使用 mergeLocalComponents？
□ 是否添加了调试信息来确认合并过程？

Phase 5 验证清单：
□ LOCAL_TEST_COMPONENTS 格式正确
□ mergeLocalComponents 合并逻辑无误
□ 所有入口文件都使用合并函数
□ 左侧菜单正确显示AI组件
□ 三层架构配置完整
□ 组件可拖拽和配置
*/
